package com.bj.disc.util

import android.content.Context
import android.net.Uri
import android.util.Base64
import com.ai3d.rfid.common.log.Logcat
import com.bj.disc.bean.MessageResponse
import com.google.android.exoplayer2.ExoPlayerFactory
import com.google.android.exoplayer2.source.ExtractorMediaSource
import com.google.android.exoplayer2.source.MediaSource
import com.google.android.exoplayer2.trackselection.DefaultTrackSelector
import com.google.android.exoplayer2.upstream.DataSource
import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory
import com.google.android.exoplayer2.util.Util
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import java.io.File
import java.io.FileOutputStream
import java.util.concurrent.ArrayBlockingQueue

class MessagePlayer(private val context: Context) {

    private val tag: String = MessagePlayer::class.java.simpleName
    private val player = ExoPlayerFactory.newSimpleInstance(context, DefaultTrackSelector())
    private val messageQueue = ArrayBlockingQueue<MessageResponse>(50)

    init {
        player.playWhenReady = true
        //configurePlayer()
        setupPlayerListener()
    }

//    private fun configurePlayer() {
//        // 配置音频播放相关参数
//        val audioAttributes = AudioAttributes.Builder()
//            .setUsage(AudioAttributes.USAGE_MEDIA)
//            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
//            .build()
//        player.audioAttributes=audioAttributes
//    }

    private fun setupPlayerListener() {
        player.addListener(object : com.google.android.exoplayer2.Player.EventListener {
            override fun onPlayerStateChanged(playWhenReady: Boolean, playbackState: Int) {
                if (playbackState == com.google.android.exoplayer2.Player.STATE_ENDED) {
                    // 播放完成，播放下一个消息
                    Logcat.d(tag,"播放结束继续下一个")
                    playNextMessage()
                }
            }
        })
    }

    fun start() {
        // 开始播放第一个消息
        playNextMessage()
    }

    fun handleMessage(messageResponse: MessageResponse) {
        // 处理收到的消息，将其加入消息队列
        messageQueue.offer(messageResponse)
        // 如果当前没有正在播放的消息，开始播放


        playNextMessage()

    }

    private fun playNextMessage() {
        if (!player.isPlaying) {
            GlobalScope.launch(Dispatchers.IO) {
                synchronized(MessagePlayer::class.java) {
                    if (!player.isPlaying) {
                        Logcat.d(tag,"开始播放")
                        val nextMessage = messageQueue.poll()
                        if (nextMessage != null) {
                            // 使用协程异步进行文件写入
                            val audioData = Base64.decode(
                                nextMessage.data?.replace("data:audio/mp3;base64,", ""),
                                Base64.DEFAULT
                            )
                            val mediaSource = buildMediaSource(audioData)
//                            nextMessage.chatUuid?.let {
//                                appendBase64DataToFileSync(it, audioData)
//                            }
                            player.prepare(mediaSource)
                            //需要写入到一个完整的文件

                        }
                    }
                }
            }
        }
    }

    //TODO 可能不需要 因为没有播放完不可以继续输入内容 如果调整则需要
    fun clearMessage() {
        if (player.isPlaying) {
            player.stop()
            //player.release()
        }

        messageQueue.clear()
    }

    private fun buildMediaSource(
        audioData: ByteArray
    ): MediaSource {
        // 将 base64 数据解码为字节数组


        // 将字节数组写入文件
        val file = File(context.cacheDir, "audio_temp.mp3")
        FileOutputStream(file).use { fos ->
            fos.write(audioData)
            fos.flush()
        }
        // 使用 ExoPlayer 构建媒体源
        val dataSourceFactory: DataSource.Factory =
            DefaultDataSourceFactory(context, Util.getUserAgent(context, "your-application-name"))
        return ExtractorMediaSource.Factory(dataSourceFactory)
            .createMediaSource(Uri.fromFile(file))
    }

//    @Synchronized
//    private fun appendBase64DataToFileSync(fileName: String, base64DataSegment: ByteArray) {
//        Logcat.d(tag, "写入数据")
//        var dir = File(DOWNLOAD_FILE_STATIC_DIR)
//        if (!dir.exists()) {
//            dir.mkdirs()
//        }
//        val file = File(DOWNLOAD_FILE_STATIC_DIR,  UUID.randomUUID().toString().replace("-","")+".mp3")
//        if(!file.exists()){
//            file.createNewFile()
//        }
//        try {
//            // 使用 true 参数表示以追加模式打开文件，如果文件不存在则创建新文件
//            val fileOutputStream = FileOutputStream(file)
//            // 将 Base64 数据段转换为字节数组
//            // 追加字节数组到文件
//            fileOutputStream.write(base64DataSegment)
//            fileOutputStream.flush()
//            // 关闭文件输出流
//            fileOutputStream.close()
//            Logcat.d(tag, "写入完成")
//        } catch (e: IOException) {
//            e.printStackTrace()
//            Logcat.d(tag, "写入异常" + e.message)
//        }
//    }

    fun pause() {
        player.playWhenReady = false
        // player.stop() // 停止当前播放
    }

    fun onResume() {
        player.playWhenReady = true
    }

    fun release() {
        // 释放资源
        player.release()
    }
}
